#ici oon va tenter de refaire explorer 3D

#on inclu les paquets utiles
library(RGtk2)
#on rajoutera rgl plus tard
#edit : maintenant
library(rgl)
#pour le moment on va essayer de garder les variables accessibles
#a la console car utile pour le débug, 
#ensuite on verra

.structure <- new.env()
.datac<-list(x=rnorm(1000),y=rnorm(1000),z=rnorm(1000),radius=runif(1000),color=rainbow(1000))

source('acp.R')


# bouton 1 qui permet de faire spawn la fenetre
fn_btn_1 <-function(button,user.data){
	# ouverture de la fenêtre rgl n1 dont on stocke l'id dans idfen de l'env
	.structure$idfen1<-open3d()
	# on stocke dans isfocus l'id de la fenêtre actuellement active
	# qui est celle avec laquelle l'utilisateur pourra interagir
	.structure$isfocus<-.structure$idfen1
	# on stocke un booleen qui permet simplement d'indiquer si une ou
	# deux fenetres sont actuellement ouvertes
	.structure$fen2isopen = FALSE
	rgl.bg(color="black") # fond noir
	# spawn des spheres d'apres les données de datac
	rgl.spheres(.datac$x,.datac$y,.datac$z,.datac$radius,.datac$color)
	# on initialise le vecteur keep qui va contenir les elements de datac 
	# qui sont selectionnés
	.structure$keep2<-seq(length = 1000,by = FALSE)
}

# bouton 2 qui permet d'activer la selection
# l'evenement se produira une fois
fn_btn_2 <-function(button,user.data){
	# si la fenetre 1 est active cela signifie qu'il n'y a qu'une seule
	# fenetre active. Le bouton 3 n'a pas encore été sollicité
	if(.structure$isfocus == .structure$idfen1)
		# on s'assure que la fenetre sur laquelle on travaille est bien la 1
		rgl.set(.structure$idfen1)
	# sinon cela signifie qu'il y a 2 fenetres actives puisque la fenetre 2
	# ne devient active qu'apres l'evenement du bouton 3
	else if(.structure$isfocus == .structure$idfen2)
		# on s'assure que la fenetre sur laquelle on travaille est bien la 2
		rgl.set(.structure$idfen2)

	# on stocke dans f le vecteur d'elements selectionnes
	f<-rgl.select3d()
	# en comparant les elements présent dans f et l'ensemble des elements
	# généré dans datac, nous arrivons à stocker dans keep un vecteur de 
	# boolens :
	# - TRUE si l'element corespondant de datac est dans la selection
	# - FALSE sinon
	.structure$keep2  <- f(.datac$x,.datac$y,.datac$z)

	# safe va contenir le nombre d'elements non selectionnés
	safe <- .structure$keep2[.structure$keep2 == FALSE]
	# si le nombre d'elements non selectionnés est différent du nombre 
	# d'elements total on passe à la suite
	# -> gestion du probleme de selection d'une region vide
	# si c'est le cas on ignore l'evenement
	if(length(safe) != length(.structure$keep2[]))
	{

		# si la fenetre 2 est fermée cela signifie que le bouton 3 n'a pas
		# ete sollicité : elements selectionnés et elements non selectionnés
		# sont dans la même fenetre
		if(.structure$fen2isopen == FALSE)
		{
			# on vide la scène rgl de tout les elements qui s'y trouvaient
			rgl.pop()
			# on fait réapparaitre les spheres de datac si celle-ci sont
			# présentes dans keep, cad qu'elle ont été sélectionnées. 
			# Leur couleur imposée localement est rouge.
			rgl.spheres(.datac$x[.structure$keep2],.datac$y[.structure$keep2],.datac$z[.structure$keep2],.datac$radius[.structure$keep2],color="red")
			# les autres spheres de datac, celles qui ne sont pas
			# sélectionnées, sont affichées avec leurs couleurs générées aléatoirement
			rgl.spheres(.datac$x[!.structure$keep2],.datac$y[!.structure$keep2],.datac$z[!.structure$keep2],.datac$radius[!.structure$keep2],.datac$color[!.structure$keep2])
		}
		
		# si la fenetre 2 est ouverte : le bouton 3 a donc ete sollicité
		# et les elements selectionnés ne sont pas dans la meme fenetre
		# que les elements non selectionnes
		else
		{
			
			# Les elements selectionnes seront dans la fenetre 1 
			rgl.set(.structure$idfen1)
			# on fait réapparaitre les spheres de datac si celle-ci sont
			# présentes dans keep, cad qu'elle ont été sélectionnées.
			# Leur couleur imposée localement est rouge.
			rgl.spheres(.datac$x[.structure$keep2],.datac$y[.structure$keep2],.datac$z[.structure$keep2],.datac$radius[.structure$keep2],color="red")
			
			# On passe la fenetre 2 en active afin qu'elle contienne les 
			# elements non selectionnes
			rgl.set(.structure$idfen2)
			# on vide les elements de la fenetre 2
			rgl.pop()
			# les autres spheres de datac, celles qui ne sont pas
			# sélectionnées, sont affichées avec leurs couleurs générées aléatoirement
			rgl.spheres(.datac$x[!.structure$keep2],.datac$y[!.structure$keep2],.datac$z[!.structure$keep2],.datac$radius[!.structure$keep2],.datac$color[!.structure$keep2])	

		}
	}
	else
		print("selection invalide")
	
}

# evenement du bouton 3 qui permet de séparer les elements selectionnés des
# elements non selectionnes
fn_btn_3<-function(button,user.data)
{
	safe <- .structure$keep2[.structure$keep2 == FALSE]
	if(length(safe) != length(.structure$keep2[]))
	{
		# on passe la fenetre 1 en active. Celle-ci contiendra
		rgl.set(.structure$idfen1)
		# on vide la fenetre 1 
		rgl.pop()
		# on fait réapparaitre les spheres de datac si celle-ci sont
		# présentes dans keep, cad qu'elle ont été sélectionnées.
		# Leur couleur imposée localement est rouge.
		rgl.spheres(.datac$x[.structure$keep2],.datac$y[.structure$keep2],.datac$z[.structure$keep2],.datac$radius[.structure$keep2],color="red")
		
		# Si la fenetre 2 est fermee c'est que nous sommes dans cet
		# evenement pour la premiere fois. Nous ouvrons la fenetre 2
		# et nous stockons sont id dans idfen2. Dans les 2 cas
		# la fenetre 2 devient la fenetre active
		if(.structure$fen2isopen == FALSE)
			.structure$idfen2<-open3d()
		else 
			rgl.set(.structure$idfen2)
		# on enregistre que la fenetre 2 est ouverte
		.structure$fen2isopen<-TRUE 
		# on s'assusre que la fenetre active est maintenant la fenetre 2
		.structure$isfocus<-.structure$idfen2
		rgl.set(.structure$idfen2)

		rgl.bg(color="black")
		# les autres spheres de datac, celles qui ne sont pas sélectionnées,
		# sont affichées avec leurs couleurs générées aléatoirement
		rgl.spheres(.datac$x[!.structure$keep2],.datac$y[!.structure$keep2],.datac$z[!.structure$keep2],.datac$radius[!.structure$keep2],.datac$color[!.structure$keep2])	
	}
	

}


fn_btn_0<-function(button,user.data)
{
.structure$fenetre = gtkWindow()
.structure$fenetre$title="Test spheres"
.structure$superpanel = gtkVBoxNew(FALSE,8)
.structure$frame=gtkFrameNew()
.structure$fenetre$add(.structure$frame)
.structure$frame$add(.structure$superpanel)
# Add button
	the.buttons <- gtkHButtonBoxNew()
	the.buttons$setBorderWidth(5)
	the.buttons$setLayout("spread")
the.buttons$setSpacing(20)
	.structure$superpanel$add(the.buttons)
	btn1 = gtkButton("Spawn")
	btn2 = gtkButton("Select")
	btn3 = gtkButton("Show 2 scenes")
	gSignalConnect(btn1,"clicked",fn_btn_1)
	gSignalConnect(btn2,"clicked",fn_btn_2)
	gSignalConnect(btn3,"clicked",fn_btn_3)
the.buttons$packStart(btn1,FALSE,FALSE,0)
the.buttons$packStart(btn2,FALSE,FALSE,0)
the.buttons$packStart(btn3,FALSE,FALSE,0)
}



chargerFichierLocal <- function(item, user.data){

dialog <- gtkFileChooserDialog("Open File", fenetreGauche, "open",
                                      "gtk-cancel", GtkResponseType["cancel"], 
              "gtk-open", GtkResponseType["accept"])

if (dialog$run() == GtkResponseType["accept"])
  {
    NomFichier <<- gtkFileChooserGetFilename(dialog)
    datas <<- read.table(NomFichier,header=TRUE)
	vueND3D()
	projeter(datas)
  }
  NomFichier <<- ""
dialog$destroy()


}

quitterExplorer3D <- function(button, user.data){
fenetreGauche$destroy()
}

panelPreTraitement <- function(){
#-------------les pretraitement
vboxpretrait <<- gtkVBoxNew(FALSE,8)
#le label
labelpretrait <<- gtkLabel("Pré-Traitements")
vboxpretrait$packStart(labelpretrait,expand=FALSE,fill=FALSE,6)
#checkbox + label
varCentreeCheck= gtkCheckButtonNewWithLabel("Variables Centrées")
varCentreeCheck$active=TRUE
vboxpretrait$packStart(varCentreeCheck,expand=FALSE,fill=FALSE,6)
#label de la liste
labelMethRed <<- gtkLabel("Méthode de réduction")
vboxpretrait$packStart(labelMethRed,expand=FALSE,fill=FALSE,6)
#liste de methode de choix
combopretrait <<- gtkComboBoxNewText()
gtkComboBoxAppendText(combopretrait,"Données brutes")
gtkComboBoxAppendText(combopretrait,"Distances Normalisées")
gtkComboBoxAppendText(combopretrait,"Variables réduites")
#on ajoute
vboxpretrait$packStart(combopretrait,expand=FALSE,fill=FALSE,6)
vboxpretrait$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxpretrait,expand=FALSE,fill=FALSE,6)
}

panelMethodProj <- function(){

#-------------methode de projection
vboxProjMethod <<- gtkVBoxNew(FALSE,8)
#le label de la division
labelProjMethod <<- gtkLabel("Méthode de projection")
vboxProjMethod$packStart(labelProjMethod,expand=FALSE,fill=FALSE,6)
#liste de choix
comboMethProj <<- gtkComboBoxNewText()
gtkComboBoxAppendText(comboMethProj,"ACP")
gtkComboBoxAppendText(comboMethProj,"Analyse Discriminante(ALD)")
gtkComboBoxAppendText(comboMethProj,"Analyse r-discriminante")
gtkComboBoxAppendText(comboMethProj,"Analyse rw-discriminante")
gtkComboBoxAppendText(comboMethProj,"ACP k plus proches voisins")
gtkComboBoxAppendText(comboMethProj,"LLE")
vboxProjMethod$packStart(comboMethProj,expand=FALSE,fill=FALSE,6)
#dual auto check + label
dualAutoCheck <<- gtkCheckButtonNewWithLabel("Dual automatique")
dualAutoCheck$active=TRUE
vboxProjMethod$packStart(dualAutoCheck,expand=FALSE,fill=FALSE,6)
#dual forcé
dualforceCheck <<- gtkCheckButtonNewWithLabel("Dual forcé") 
vboxProjMethod$packStart(dualforceCheck,expand=FALSE,fill=FALSE,6)
#button Calculer
calcBtn <<- gtkButton("Calculer")
vboxProjMethod$packStart(calcBtn,expand=FALSE,fill=TRUE,6)
vboxProjMethod$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxProjMethod,expand=FALSE,fill=FALSE,6)
}

panelCrop <- function(){
#Crop
vboxCrop <<- gtkVBoxNew(FALSE,8)
labelCrop <<- gtkLabel("Crop")
buttonNewCrop <<- gtkButton("Nouveau Crop")
buttonLimitCrop <<- gtkButton("Crop ! (limiter à la selection)")
vboxPosCentre <<- gtkVBoxNew(FALSE,8)
labelPosCentre <<- gtkLabel("Position du centre de la zone")
scaleCentreX <<- gtkHScaleNewWithRange(0,100,1)
scaleCentreY <<- gtkHScaleNewWithRange(0,100,1)
scaleCentreZ <<- gtkHScaleNewWithRange(0,100,1)
gtkRangeSetValue(scaleCentreX,50)
gtkRangeSetValue(scaleCentreY,50)
gtkRangeSetValue(scaleCentreZ,50)
vboxPosCentre$packStart(labelPosCentre,expand=FALSE,fill=FALSE,6)
vboxPosCentre$packStart(scaleCentreX,expand=TRUE,fill=FALSE,6)
vboxPosCentre$packStart(scaleCentreY,expand=TRUE,fill=FALSE,6)
vboxPosCentre$packStart(scaleCentreZ,expand=TRUE,fill=FALSE,6)
vboxPosCentre$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)

vboxTailleZone <<- gtkVBoxNew(FALSE,8)
labelTailleZone <<- gtkLabel("Taille de la zone")
scaleTailleX <<- gtkHScaleNewWithRange(0,100,1)
scaleTailleY <<- gtkHScaleNewWithRange(0,100,1)
scaleTailleZ <<- gtkHScaleNewWithRange(0,100,1)
gtkRangeSetValue(scaleTailleX,1)
gtkRangeSetValue(scaleTailleY,1)
gtkRangeSetValue(scaleTailleZ,1)
vboxTailleZone$packStart(labelTailleZone,expand=FALSE,fill=FALSE,6)
vboxTailleZone$packStart(scaleTailleX,expand=TRUE,fill=FALSE,6)
vboxTailleZone$packStart(scaleTailleY,expand=TRUE,fill=FALSE,6)
vboxTailleZone$packStart(scaleTailleZ,expand=TRUE,fill=FALSE,6)
vboxTailleZone$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxCrop$packStart(labelCrop,expand=FALSE,fill=FALSE,6)
vboxCrop$packStart(buttonNewCrop,expand=FALSE,fill=FALSE,6)
vboxCrop$packStart(buttonLimitCrop,expand=FALSE,fill=FALSE,6)
vboxCrop$packStart(vboxPosCentre,expand=FALSE,fill=FALSE,6)
vboxCrop$packStart(vboxTailleZone,expand=FALSE,fill=FALSE,6)
vboxCrop$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxCrop,expand=FALSE,fill=FALSE,6)
}

panelNoyau <- function(){
#-------------noyau
vboxNoyau <<- gtkVBoxNew(FALSE,8)
#label de la division
labelNoyau <<- gtkLabel("Noyaux")
vboxNoyau$packStart(labelNoyau,expand=FALSE,fill=FALSE,6)
#liste de choix
comboNoyau <<- gtkComboBoxNewText()
gtkComboBoxAppendText(comboNoyau,"-Choisir une méthode-")
gtkComboBoxAppendText(comboNoyau,"Linéaire")
gtkComboBoxAppendText(comboNoyau,"Polynomiale")
gtkComboBoxAppendText(comboNoyau,"RBF")
gtkComboBoxAppendText(comboNoyau,"Sigmoide")
gtkComboBoxAppendText(comboNoyau,"ISOMAP")
gtkComboBoxAppendText(comboNoyau,"LLE")
vboxNoyau$packStart(comboNoyau,expand=FALSE,fill=FALSE,6)
vboxNoyau$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxNoyau,expand=FALSE,fill=FALSE,6)
}

panelModeAfficheSVM <- function(){
#ModeAfficheSVM
vboxModeAffSVM <<- gtkVBoxNew(FALSE,8)
labelModCalcul <<- gtkLabel("Modes de calcul : ")
comboModCalcul <<- gtkComboBoxNewText()
gtkComboBoxAppendText(comboModCalcul,"SVM sur les données brutes")
labelModeAff <<- gtkLabel("Mode d'affichage : ")
comboModAff <<- gtkComboBoxNewText()
gtkComboBoxAppendText(comboModAff,"plan")
buttonAfficheSVM <<- gtkButton("Afficher")
vboxModeAffSVM$packStart(labelModCalcul,expand=FALSE,fill=FALSE,6)
vboxModeAffSVM$packStart(comboModCalcul,expand=FALSE,fill=FALSE,6)
vboxModeAffSVM$packStart(labelModeAff,expand=FALSE,fill=FALSE,6)
vboxModeAffSVM$packStart(comboModAff,expand=FALSE,fill=FALSE,6)
vboxModeAffSVM$packStart(buttonAfficheSVM,expand=FALSE,fill=FALSE,6)
vboxModeAffSVM$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxModeAffSVM,expand=FALSE,fill=FALSE,6)
}

panelOutilLoupe <- function(){
#---------outils loupe
vboxLoupe <<- gtkVBoxNew(FALSE,8)
labelLoupe <<- gtkLabel("Outil loupe")
hboxDiameter <<- gtkHBoxNew(FALSE,8)
hboxCoeff <<- gtkHBoxNew(FALSE,8)
hboxOpacite <<- gtkHBoxNew(FALSE,8)
labelLoupeDiam <<- gtkLabel("Diamètre")
labelLoupeCoeff <<-  gtkLabel("Coefficient")
labelLoupeOpacite <<- gtkLabel("Opacité")
scaleLoupeDiam <<- gtkHScaleNewWithRange(0,100,1)
scaleLoupeCoeffcient <<- gtkHScaleNewWithRange(0,5,1)
scaleLoupeOpacite <<- gtkHScaleNewWithRange(0,100,1)
gtkRangeSetValue(scaleLoupeCoeffcient,2)
gtkRangeSetValue(scaleLoupeOpacite,75)
hboxDiameter$packStart(labelLoupeDiam,expand=FALSE,fill=FALSE,6)
hboxDiameter$packStart(scaleLoupeDiam,expand=TRUE,fill=TRUE,6)
hboxCoeff$packStart(labelLoupeCoeff,expand=FALSE,fill=FALSE,6)
hboxCoeff$packStart(scaleLoupeCoeffcient,expand=TRUE,fill=TRUE,6)
hboxOpacite$packStart(labelLoupeOpacite,expand=FALSE,fill=FALSE,6)
hboxOpacite$packStart(scaleLoupeOpacite,expand=TRUE,fill=TRUE,6)
vboxLoupe$packStart(labelLoupe,expand=FALSE,fill=FALSE,6)
vboxLoupe$packStart(hboxDiameter,expand=FALSE,fill=FALSE,6)
vboxLoupe$packStart(hboxCoeff,expand=FALSE,fill=FALSE,6)
vboxLoupe$packStart(hboxOpacite,expand=FALSE,fill=FALSE,6)
vboxLoupe$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxLoupe,expand=FALSE,fill=FALSE,6)
}

panelClassification <- function(){
#Classification
vboxClassification <<- gtkVBoxNew(FALSE,8)
labelClassification <<- gtkLabel("Classification")
comboClassif <<- gtkComboBoxNewText()
gtkComboBoxAppendText(comboClassif,"--Choisir une méthode--")
gtkComboBoxAppendText(comboClassif,"Mélange de lois")
gtkComboBoxAppendText(comboClassif,"Kmeans")
gtkComboBoxAppendText(comboClassif,"Kmeans Flou")
gtkComboBoxAppendText(comboClassif,"DBSCAN")
gtkComboBoxAppendText(comboClassif,"Minkowski")
gtkComboBoxAppendText(comboClassif,"Hiérarchique Lien Simple")
vboxClassification$packStart(labelClassification,expand=FALSE,fill=FALSE,6)
vboxClassification$packStart(comboClassif,expand=FALSE,fill=FALSE,6)
vboxClassification$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxClassification,expand=FALSE,fill=FALSE,6)
}

panelRemiseZero <- function(){
#-------------remise à zéro
vboxRemiseZero <<- gtkVBoxNew(FALSE,8)
#label de la division
labelRemiseZero <<- gtkLabel("Resmise à zéro des transformation")
vboxRemiseZero$packStart(labelRemiseZero,expand=FALSE,fill=FALSE,6)
buttonRaZ <<- gtkButton("Remettre à zéro")
vboxRemiseZero$packStart(buttonRaZ,expand=FALSE,fill=FALSE,6)
vboxRemiseZero$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxRemiseZero,expand=FALSE,fill=FALSE,6)
}

panelSVM <- function(){
#------------svm
vboxSVM <<- gtkVBoxNew(FALSE,8)
labelSVM <<- gtkLabel("SVM")
hboxConstRegul <<- gtkHBoxNew(FALSE,8)
entryConstRegul <<- gtkEntryNew()
labelConstRegul <<- gtkLabel("Constante de régulation")
hboxConstRegul$packStart(entryConstRegul,expand=FALSE,fill=FALSE,6)
hboxConstRegul$packStart(labelConstRegul,expand=FALSE,fill=FALSE,6)
labelSVMChoixClass <<- gtkLabel("Choisissez entre la classe")
hboxSVMChoixClass <<- gtkHBoxNew(FALSE,8)
comboSVMClass1 <<- gtkComboBoxNewText()
#a remplir au chargement
comboSVMClass2 <<- gtkComboBoxNewText()
#a remplir
labelSVMET <<- gtkLabel("ET")
hboxSVMChoixClass$packStart(comboSVMClass1,expand=FALSE,fill=FALSE,6)
hboxSVMChoixClass$packStart(labelSVMET,expand=FALSE,fill=FALSE,6)
hboxSVMChoixClass$packStart(comboSVMClass2,expand=FALSE,fill=FALSE,6)

vboxSVM$packStart(labelSVM,expand=FALSE,fill=FALSE,6)
vboxSVM$packStart(hboxConstRegul,expand=FALSE,fill=FALSE,6)
vboxSVM$packStart(labelSVMChoixClass,expand=FALSE,fill=FALSE,6)
vboxSVM$packStart(hboxSVMChoixClass,expand=FALSE,fill=FALSE,6)
vboxSVM$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)

vboxgen$packStart(vboxSVM,expand=FALSE,fill=FALSE,6)
}

panelStable <- function(){
#-----------stables
vboxStable <<- gtkVBoxNew(FALSE,8)
labelStable <<- gtkLabel("Stables")
#nbClass
hboxNbClassKMeans <<- gtkHBoxNew(FALSE,8)
labelNbClassKMeans <<- gtkLabel("Nombre de classes pour KMeans")
entryNbClassKMeans <<- gtkEntryNew()
gtkEntrySetText(entryNbClassKMeans,"5")
hboxNbClassKMeans$packStart(labelNbClassKMeans,expand=FALSE,fill=FALSE,6)
hboxNbClassKMeans$packStart(entryNbClassKMeans,expand=FALSE,fill=FALSE,6)
#nbRun
hboxNbRunKMeans <<- gtkHBoxNew(FALSE,8)
labelNbRunKMeans <<- gtkLabel("Nombre de runs de KMeans")
entryNbRunKMeans <<- gtkEntryNew()
gtkEntrySetText(entryNbRunKMeans,"5")
hboxNbRunKMeans$packStart(labelNbRunKMeans,expand=FALSE,fill=FALSE,6)
hboxNbRunKMeans$packStart(entryNbRunKMeans,expand=FALSE,fill=FALSE,6)
buttonStables <<- gtkButton("Recalculer")

vboxStable$packStart(labelStable,expand=FALSE,fill=FALSE,6)
vboxStable$packStart(hboxNbClassKMeans,expand=FALSE,fill=FALSE,6)
vboxStable$packStart(hboxNbRunKMeans,expand=FALSE,fill=FALSE,6)
vboxStable$packStart(buttonStables,expand=FALSE,fill=FALSE,6)
vboxStable$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxStable,expand=FALSE,fill=FALSE,6)
}

panelAxeProj <- function(){
#------------axe de projection
vboxAxeProj <<- gtkVBoxNew(FALSE,8)
#label de la division
axeProjLabel <<- gtkLabel("axes de projections")
vboxAxeProj$packStart(axeProjLabel,expand=FALSE,fill=FALSE,6)
checkZoomDim <<- gtkCheckButtonNewWithLabel("Zoom dimension peu discriminante")
checkCentreNuageImage <<- gtkCheckButtonNewWithLabel("Centrage Nuage/image")

vboxAxeProj$packStart(checkZoomDim,expand=FALSE,fill=FALSE,6)
vboxAxeProj$packStart(checkCentreNuageImage,expand=FALSE,fill=FALSE,6)
#dimension hbox
hboxDim <<- gtkHBoxNew(FALSE,8)
spin1 <<- gtkSpinButtonNewWithRange(1,999,1)
spin2 <<- gtkSpinButtonNewWithRange(1,999,1)
spin3 <<- gtkSpinButtonNewWithRange(1,999,1)
btnafficher <<- gtkButton("Afficher")
hboxDim$packStart(spin1,expand=FALSE,fill=FALSE,6)
hboxDim$packStart(spin2,expand=FALSE,fill=FALSE,6)
hboxDim$packStart(spin3,expand=FALSE,fill=FALSE,6)
hboxDim$packStart(btnafficher,expand=FALSE,fill=FALSE,6)
vboxAxeProj$packStart(hboxDim,expand=FALSE,fill=FALSE,6)
hboxcolor <<- gtkHBoxNew(FALSE,8)
checkDimcolor <<- gtkCheckButtonNewWithLabel("Dimension couleur")
spinDimCouleur <<- gtkSpinButtonNewWithRange(1,999,1)
hboxcolor$packStart(checkDimcolor,expand=FALSE,fill=FALSE,6)
hboxcolor$packStart(spinDimCouleur,expand=FALSE,fill=FALSE,6)
vboxAxeProj$packStart(hboxcolor,expand=FALSE,fill=FALSE,6)
vboxAxeProj$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxAxeProj,expand=FALSE,fill=FALSE,6)
}

panelCourbes2D <- function(){
#-------------Courbes2D
vboxCourbes <<- gtkVBoxNew(FALSE,8)
labelCourbes <<- gtkLabel("Courbes 2D")
comboCourbes <<- gtkComboBoxNewText()
gtkComboBoxAppendText(comboCourbes,"Shepard simple")
gtkComboBoxAppendText(comboCourbes,"2D (symboles)")
gtkComboBoxAppendText(comboCourbes,"2D (labels)")
gtkComboBoxAppendText(comboCourbes,"Contributions (axe principal)")
gtkComboBoxAppendText(comboCourbes,"CosCarrés (axe principal)")
gtkComboBoxAppendText(comboCourbes,"Cellules de Voronoi (Proximité 2D-3D)")
gtkComboBoxAppendText(comboCourbes,"Cellules de Voronoi (Proximité 2D-xD)")
gtkComboBoxAppendText(comboCourbes,"Cellules de Voronoi (Proximité 3D-xD)")
gtkComboBoxAppendText(comboCourbes,"Cellules de Voronoi (Distorsion 2D-3D)")
gtkComboBoxAppendText(comboCourbes,"Cellules de Voronoi (Distorsion 2D-xD)")
gtkComboBoxAppendText(comboCourbes,"Cellules de Voronoi (Distorsion 3D-xD)")
vboxCourbes$packStart(labelCourbes,expand=FALSE,fill=FALSE,6)
vboxCourbes$packStart(comboCourbes,expand=FALSE,fill=FALSE,6)
vboxCourbes$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxCourbes,expand=FALSE,fill=FALSE,6)
}

panelCoverTree <- function(){
#------------- Arbre de couvrement minimal
vboxCoverTree <<- gtkVBoxNew(FALSE,8)
labelCoverTree <<- gtkLabel("Arbre de recouvrement minimal")
buttonCovreTree <<- gtkButton("Afficher")
vboxCoverTree$packStart(labelCoverTree,expand=FALSE,fill=FALSE,6)
vboxCoverTree$packStart(buttonCovreTree,expand=FALSE,fill=FALSE,6)
vboxCoverTree$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxCoverTree,expand=FALSE,fill=FALSE,6)
}

panelAttrib <- function(){
#-------------Attributs complementaires
vboxAttrib <<- gtkVBoxNew(FALSE,6)
labelAttrib <<- gtkLabel("Attributs complémentaires")
checkDAspe <<- gtkCheckButtonNewWithLabel("D.A. spécifiques")
checkTexture <<- gtkCheckButtonNewWithLabel("Texture")
hboxattrib_classe <<- gtkHBoxNew(FALSE,6)
hboxattrib_DonneeAsso <<- gtkHBoxNew(FALSE,6)
hboxattrib_Label <<- gtkHBoxNew(FALSE,6)
hboxattrib_Forme <<- gtkHBoxNew(FALSE,6)
hboxattrib_Couleur <<- gtkHBoxNew(FALSE,6)
label_attrib_classe <<- gtkLabel("Classe ")
label_attrib_DonneeAsso <<- gtkLabel("Données associées ")
label_attrib_Label <<- gtkLabel("Label ")
label_attrib_forme <<- gtkLabel("Forme ")
label_attrib_couleur <<- gtkLabel("Couleur ")
combo_attrib_classe <<- gtkComboBoxNewText()
combo_attrib_DonneeAsso <<- gtkComboBoxNewText()
combo_attrib_Label <<- gtkComboBoxNewText()
combo_attrib_Forme <<- gtkComboBoxNewText()
combo_attrib_Couleur <<- gtkComboBoxNewText()

hboxattrib_classe$packStart(label_attrib_classe,expand=FALSE,fill=FALSE,6)
hboxattrib_classe$packStart(combo_attrib_classe,expand=FALSE,fill=FALSE,6)

hboxattrib_DonneeAsso$packStart(label_attrib_DonneeAsso,expand=FALSE,fill=FALSE,6)
hboxattrib_DonneeAsso$packStart(combo_attrib_DonneeAsso,expand=FALSE,fill=FALSE,6)

hboxattrib_Label$packStart(label_attrib_Label,expand=FALSE,fill=FALSE,6)
hboxattrib_Label$packStart(combo_attrib_Label,expand=FALSE,fill=FALSE,6)

hboxattrib_Forme$packStart(label_attrib_forme,expand=FALSE,fill=FALSE,6)
hboxattrib_Forme$packStart(combo_attrib_Forme,expand=FALSE,fill=FALSE,6)

hboxattrib_Couleur$packStart(label_attrib_couleur,expand=FALSE,fill=FALSE,6)
hboxattrib_Couleur$packStart(combo_attrib_Couleur,expand=FALSE,fill=FALSE,6)


#
# CES COMBOS SONT A REMPLIR APRES CHARGEMENT DE FICHIER
#
vboxAttrib$packStart(labelAttrib,expand=FALSE,fill=FALSE,6)
vboxAttrib$packStart(hboxattrib_classe,expand=FALSE,fill=FALSE,6)
vboxAttrib$packStart(hboxattrib_DonneeAsso,expand=FALSE,fill=FALSE,6)
vboxAttrib$packStart(checkDAspe,expand=FALSE,fill=FALSE,6)
vboxAttrib$packStart(hboxattrib_Label,expand=FALSE,fill=FALSE,6)
vboxAttrib$packStart(hboxattrib_Forme,expand=FALSE,fill=FALSE,6)
vboxAttrib$packStart(hboxattrib_Couleur,expand=FALSE,fill=FALSE,6)
vboxAttrib$packStart(checkTexture,expand=FALSE,fill=FALSE,6)
vboxAttrib$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxAttrib,expand=FALSE,fill=FALSE,6)
}

panelParamEspace <- function(){
#paramEspace
vboxParamEspace <<- gtkVBoxNew(FALSE,8)
labelParamEspace <<- gtkLabel("Paramètres d'espace")
hboxDilatObj <<- gtkHBoxNew(FALSE,8)
labelDilatObj <<- gtkLabel("Dilatation objets")
scaleDilatObj=  gtkHScaleNewWithRange(1,100,1)
hboxDilatObj$packStart(labelDilatObj,expand=FALSE,fill=FALSE,6)
hboxDilatObj$packStart(scaleDilatObj,expand=TRUE,fill=TRUE,6)

hboxDilatESP <<- gtkHBoxNew(FALSE,8)
labelDilatESP <<- gtkLabel("Dialatation de l'espace")
scaleDilatESP <<- gtkHScaleNewWithRange(1,100,1)
hboxDilatESP$packStart(labelDilatESP,expand=FALSE,fill=FALSE,6)
hboxDilatESP$packStart(scaleDilatESP,expand=TRUE,fill=TRUE,6)
gtkRangeSetValue(scaleDilatObj,5)

vboxParamEspace$packStart(labelParamEspace,expand=FALSE,fill=FALSE,6)
vboxParamEspace$packStart(hboxDilatObj,expand=FALSE,fill=FALSE,6)
vboxParamEspace$packStart(hboxDilatESP,expand=FALSE,fill=FALSE,6)
vboxParamEspace$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxParamEspace,expand=FALSE,fill=FALSE,6)
}

panelParamStyle<- function(){
#parametreStyle
vboxParamStyle <<- gtkVBoxNew(FALSE,8)
labelParamStyle <<- gtkLabel("Paramètres de style")

hbox_BG <<- gtkHBoxNew(FALSE,8)
labelParam_BG <<- gtkLabel("Fond d'espace")
combo_BG <<- gtkComboBoxNewText()
gtkComboBoxAppendText(combo_BG,"Sombre")
gtkComboBoxAppendText(combo_BG,"Clair")
gtkComboBoxAppendText(combo_BG,"Blanc")
hbox_BG$packStart(labelParam_BG,expand=FALSE,fill=FALSE,6)
hbox_BG$packStart(combo_BG,expand=FALSE,fill=FALSE,6)

hbox_quadrillage <<- gtkHBoxNew(FALSE,8)
labelParamQuadrill <<- gtkLabel("Quadrillage d'espace")
combo_QD <<- gtkComboBoxNewText()
gtkComboBoxAppendText(combo_QD,"Standard")
gtkComboBoxAppendText(combo_QD,"Cube")
gtkComboBoxAppendText(combo_QD,"SimpleColor")
gtkComboBoxAppendText(combo_QD,"XLStat")
gtkComboBoxAppendText(combo_QD,"Sphère")
hbox_quadrillage$packStart(labelParamQuadrill,expand=FALSE,fill=FALSE,6)
hbox_quadrillage$packStart(combo_QD,expand=FALSE,fill=FALSE,6)
vboxParamStyle$packStart(labelParamStyle,expand=FALSE,fill=FALSE,6)
vboxParamStyle$packStart(hbox_BG,expand=FALSE,fill=FALSE,6)
vboxParamStyle$packStart(hbox_quadrillage,expand=FALSE,fill=FALSE,6)
vboxParamStyle$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxParamStyle,expand=FALSE,fill=FALSE,6)
}

panelMDSClassique <- function(){
#----------MDS classique
vboxMDSClassique <<- gtkVBoxNew(FALSE,8)
label_MDS <<- gtkLabel("MDS classique")
button_MDS <<- gtkButton("Calculer")
vboxMDSClassique$packStart(label_MDS,expand=FALSE,fill=FALSE,6)
vboxMDSClassique$packStart(button_MDS,expand=FALSE,fill=FALSE,6)
vboxMDSClassique$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxMDSClassique,expand=FALSE,fill=FALSE,6)
}

panelControlePlusProcheVoisin <- function(){
#controle plus proche voisin
vboxControlePlusProcheVoisin <<- gtkVBoxNew(FALSE,8)
labelPlusProcheVoisin <<- gtkLabel("Controle plus proche voisin")
comboTypeControlePlusProcheVoisin <<- gtkComboBoxNewText()
gtkComboBoxAppendText(comboTypeControlePlusProcheVoisin,"Cones")
gtkComboBoxAppendText(comboTypeControlePlusProcheVoisin,"Illumination")
comboPlusProcheVoisinChoixDimension <<- gtkComboBoxNewText()
#
#A remplir dans chargement
#
checkPlusProcheVoisinAffMalCLasse <<- gtkCheckButtonNewWithLabel("Afficher mal classés")
checkPlusProcheVoisinAffEllipsoide <<- gtkCheckButtonNewWithLabel("Afficher ellipsoide")
buttonPlusProcheVoisinNextEllips <<- gtkButton("Ellipsoide suivante")
buttonPlusProcheVoisinPrevEllips <<- gtkButton("Ellipsoide précédente")
buttonZoomEllips <<- gtkButton("Zoom ellipsoide")
buttonZoomMalClass= gtkButton("Zoom mal classés")
labelPlusProcheVoisinDens <<- gtkLabel("Densité")
scalePlusProcheVoisinDensite <<- gtkHScaleNewWithRange(0,100,1)
buttonPlusProcheVoisinAffCube <<- gtkButton("Afficher cubes")
vboxControlePlusProcheVoisin$packStart(labelPlusProcheVoisin,expand=FALSE,fill=FALSE,6)
vboxControlePlusProcheVoisin$packStart(comboTypeControlePlusProcheVoisin,expand=FALSE,fill=FALSE,6)
vboxControlePlusProcheVoisin$packStart(comboPlusProcheVoisinChoixDimension,expand=FALSE,fill=FALSE,6)
vboxControlePlusProcheVoisin$packStart(checkPlusProcheVoisinAffMalCLasse,expand=FALSE,fill=FALSE,6)
vboxControlePlusProcheVoisin$packStart(checkPlusProcheVoisinAffEllipsoide,expand=FALSE,fill=FALSE,6)
vboxControlePlusProcheVoisin$packStart(buttonPlusProcheVoisinNextEllips,expand=FALSE,fill=FALSE,6)
vboxControlePlusProcheVoisin$packStart(buttonPlusProcheVoisinPrevEllips,expand=FALSE,fill=FALSE,6)
vboxControlePlusProcheVoisin$packStart(buttonZoomEllips,expand=FALSE,fill=FALSE,6)
vboxControlePlusProcheVoisin$packStart(buttonZoomMalClass,expand=FALSE,fill=FALSE,6)
vboxControlePlusProcheVoisin$packStart(labelPlusProcheVoisinDens,expand=FALSE,fill=FALSE,6)
vboxControlePlusProcheVoisin$packStart(scalePlusProcheVoisinDensite,expand=FALSE,fill=FALSE,6)
vboxControlePlusProcheVoisin$packStart(buttonPlusProcheVoisinAffCube,expand=FALSE,fill=FALSE,6)
vboxControlePlusProcheVoisin$packStart(gtkHSeparatorNew(),expand=FALSE,fill=FALSE,6)
vboxgen$packStart(vboxControlePlusProcheVoisin,expand=FALSE,fill=FALSE,6)
}

allInvisible <- function(){
vboxAttrib$visible=FALSE
vboxAxeProj$visible=FALSE
vboxClassification$visible=FALSE
vboxControlePlusProcheVoisin$visible=FALSE
vboxCourbes$visible=FALSE
vboxCoverTree$visible=FALSE
vboxCrop$visible=FALSE
vboxLoupe$visible=FALSE
vboxMDSClassique$visible=FALSE
vboxModeAffSVM$visible=FALSE
vboxNoyau$visible=FALSE
vboxParamEspace$visible=FALSE
vboxParamStyle$visible=FALSE
vboxPosCentre$visible=FALSE
vboxpretrait$visible=FALSE
vboxProjMethod$visible=FALSE
vboxRemiseZero$visible=FALSE
vboxStable$visible=FALSE
vboxSVM$visible=FALSE
vboxTailleZone$visible=FALSE
}

vueND3D <- function (item,user.data){
allInvisible()
vboxpretrait$visible=TRUE
vboxProjMethod$visible=TRUE
vboxNoyau$visible=TRUE
vboxRemiseZero$visible=TRUE
vboxAxeProj$visible=TRUE
vboxCourbes$visible=TRUE
vboxAttrib$visible=TRUE
vboxCoverTree$visible=TRUE
}

vueDistance3D <- function(item , user.data){
allInvisible()
vboxMDSClassique$visible=TRUE
vboxRemiseZero$visible=TRUE
vboxAxeProj$visible=TRUE
vboxCourbes$visible=TRUE
vboxAttrib$visible=TRUE
vboxControlePlusProcheVoisin$visible=TRUE
vboxNoyau$visible=TRUE
vboxCoverTree$visible=TRUE

}


vueAspect <- function(item, user.data){
allInvisible()
vboxAttrib$visible=TRUE
vboxParamStyle$visible=TRUE
vboxParamEspace$visible=TRUE
vboxLoupe$visible=TRUE
gtkWindowResize(fenetreGauche,350,768)
}

vueClassification <- function(item, user.data){
allInvisible()
vboxClassification$visible=TRUE
vboxCoverTree$visible=TRUE
vboxStable$visible=TRUE
vboxAxeProj$visible=TRUE
vboxCourbes$visible=TRUE
vboxAttrib$visible=TRUE
vboxControlePlusProcheVoisin$visible=TRUE
gtkWindowResize(fenetreGauche,350,768)
}

vueSVM <- function(item, user.data){
allInvisible()
vboxSVM$visible=TRUE
vboxModeAffSVM$visible=TRUE
vboxAttrib$visible=TRUE
vboxNoyau$visible=TRUE
gtkWindowResize(fenetreGauche,350,768)
}

vueCrop <- function(item, user.data){
allInvisible()
vboxCrop$visible=TRUE
gtkWindowResize(fenetreGauche,350,768)
}


fenetreGauche <<- gtkWindow()
fenetreGauche$title="Explorer3D"



#pour le codage des menus , regarder le pdf
#pour comprendre la hiérarchie entre la menuBar
#le menu, et les menu item

#menu_fichier
menu_fichier <<- gtkMenuNew()
#il va servir de container pour les item du menu
#en gros c'est un sous menu

#les entrées du sous menu
#fichierlocal
#fichierdistant
#chargerScript
#sauverProjet
#chargerProjet
#OutilImport
#Quitter
fichierlocal_item <<- gtkMenuItemNewWithLabel("Ouvrir un fichier local")
fichierdistant_item <<- gtkMenuItemNewWithLabel("Ouvrir un fichier distant")
chargerScript_item <<- gtkMenuItemNewWithLabel("Charger un Script")
sauverProjet_item <<- gtkMenuItemNewWithLabel("Sauvegarder un projet")
chargerProjet_item <<- gtkMenuItemNewWithLabel("Charger un projet")
OutilImport_item <<- gtkMenuItemNewWithLabel("Outil d'importation de données")
Quitter_item <<- gtkMenuItemNewWithLabel("Quitter")

#on ajoute les item dnas le sous menu
gtkMenuShellAppend(menu_fichier,fichierlocal_item)
gtkMenuShellAppend(menu_fichier,fichierdistant_item)
gtkMenuShellAppend(menu_fichier,gtkSeparatorMenuItemNew())
gtkMenuShellAppend(menu_fichier,gtkSeparatorMenuItemNew())
gtkMenuShellAppend(menu_fichier,chargerScript_item)
gtkMenuShellAppend(menu_fichier,gtkSeparatorMenuItemNew())
gtkMenuShellAppend(menu_fichier,sauverProjet_item)
gtkMenuShellAppend(menu_fichier,chargerProjet_item)
gtkMenuShellAppend(menu_fichier,gtkSeparatorMenuItemNew())
gtkMenuShellAppend(menu_fichier,OutilImport_item)
gtkMenuShellAppend(menu_fichier,gtkSeparatorMenuItemNew())
gtkMenuShellAppend(menu_fichier,gtkSeparatorMenuItemNew())
gtkMenuShellAppend(menu_fichier,Quitter_item)

#lui c'est le nom affiché dans la marre de menu
fichier_item <<- gtkMenuItemNewWithLabel("Fichier")
gtkMenuItemSetSubmenu(fichier_item,menu_fichier)


#container pour la perspective
menu_perspective <<- gtkMenuNew()
#contenu du sous menu
#ND->3D
#Distance-> 3D
#Aspect
#Classification
#SVM
ND3D_item <<- gtkMenuItemNewWithLabel("ND -> 3D")
Distance3D_item <<- gtkMenuItemNewWithLabel("Distance -> 3D")
Aspect_item <<- gtkMenuItemNewWithLabel("Aspect")
Classification_item <<- gtkMenuItemNewWithLabel("Classification")
SVM_item <<- gtkMenuItemNewWithLabel("SVM")

#on ajoute les item dnas le sous menu
gtkMenuShellAppend(menu_perspective,ND3D_item)
gtkMenuShellAppend(menu_perspective,Distance3D_item)
gtkMenuShellAppend(menu_perspective,gtkSeparatorMenuItemNew())
gtkMenuShellAppend(menu_perspective,Aspect_item)
gtkMenuShellAppend(menu_perspective,gtkSeparatorMenuItemNew())
gtkMenuShellAppend(menu_perspective,Classification_item)
gtkMenuShellAppend(menu_perspective,SVM_item)

#Perspective affiché dans le menu
perspective_item <<- gtkMenuItemNewWithLabel("Perspective")
gtkMenuItemSetSubmenu(perspective_item,menu_perspective)

#contrainer pour le menu Outils
menu_outils <<- gtkMenuNew()
#contenu du sous menu
#Crop
#Echantilloner
#Interaction
#VoyageATraverDimension
#ExplorerAPartirImage
#Options
Crop_item <<- gtkMenuItemNewWithLabel("Crop")
Echantilloner_item <<- gtkMenuItemNewWithLabel("Echantilloner")
Interaction_item <<- gtkMenuItemNewWithLabel("Interaction")
VoyageATraverDimension_item <<- gtkMenuItemNewWithLabel("Voyage à travers les dimensions")
ExplorerAPartirImage_item <<- gtkCheckMenuItemNewWithLabel("Explorer à partir d'images")
Options_item <<- gtkMenuItemNewWithLabel("Options")

#on ajouter dans le sous menu
gtkMenuShellAppend(menu_outils,Crop_item)
gtkMenuShellAppend(menu_outils,gtkSeparatorMenuItemNew())
gtkMenuShellAppend(menu_outils,Echantilloner_item)
gtkMenuShellAppend(menu_outils,gtkSeparatorMenuItemNew())
gtkMenuShellAppend(menu_outils,Interaction_item)
gtkMenuShellAppend(menu_outils,VoyageATraverDimension_item)
gtkMenuShellAppend(menu_outils,gtkSeparatorMenuItemNew())
gtkMenuShellAppend(menu_outils,ExplorerAPartirImage_item)
gtkMenuShellAppend(menu_outils,Options_item)

#Outils afficher dans la barre de menu
outil_item <<- gtkMenuItemNewWithLabel("Outils")
gtkMenuItemSetSubmenu(outil_item,menu_outils)

#container pour l'aide
menu_aide <<- gtkMenuNew()
#contenu de l'aide
#manuelOnline
#aPropos
manuelOnline_item <<- gtkMenuItemNewWithLabel("Manuel en ligne")
aPropos_item <<- gtkMenuItemNewWithLabel("À propos d'Explorer3D")

#on ajoute dans le sous menu
gtkMenuShellAppend(menu_aide,manuelOnline_item)
gtkMenuShellAppend(menu_aide,aPropos_item)

#Aide afficher dans la barre de menu
Aide_item =gtkMenuItemNewWithLabel("Aide")
gtkMenuItemSetSubmenu(Aide_item,menu_aide)

#Demo rgl
Demo_item = gtkMenuItemNewWithLabel("Demo2")


#la barre de menu
menu_barre <<- gtkMenuBarNew(show=TRUE)
gtkMenuShellAppend(menu_barre,fichier_item)
gtkMenuShellAppend(menu_barre,perspective_item)
gtkMenuShellAppend(menu_barre,outil_item)
gtkMenuShellAppend(menu_barre,Aide_item)
gtkMenuShellAppend(menu_barre,Demo_item)
#fenetreGauche$add(menu_barre)
# ---fin du menu---
superPanel <<- gtkVBoxNew(FALSE,8)
fenetreGauche$add(superPanel)
superPanel$packStart(menu_barre,expand=FALSE,fill=FALSE)
scrollWin <<- gtkScrolledWindowNew()
superPanel$add(scrollWin)



#-------------la progressBar
progresBar <<- gtkProgressBarNew()
gtkProgressBarSetFraction(progresBar,0.6)
gtkProgressBarSetText(progresBar,"testprogbar")
superPanel$packStart(progresBar,expand=FALSE,fill=FALSE)

#-------------on tente la statusBar
statusBar <<- gtkStatusbarNew()
superPanel$packStart(statusBar,expand=FALSE,fill=FALSE,6)
contextStatBar <<- gtkStatusbarGetContextId(statusBar,"test")
gtkStatusbarPush(statusBar,contextStatBar,"test")
gtkStatusbarPush(statusBar,contextStatBar,"test2")
gtkStatusbarPush(statusBar,contextStatBar,"testStatusBar")
#c'est pas super prorpre mais ça marche
#MAJ: il emblerait que se soit la bonne et seule méthode
#à utiliser, donc finalement c'est propre

#on attaque les panels à mettre dans la ScrolledWindow


vboxgen <<- gtkVBoxNew(FALSE,1)

gtkScrolledWindowAddWithViewport(scrollWin,vboxgen)
panelAttrib()

panelAxeProj()
panelClassification()
panelControlePlusProcheVoisin()
panelCourbes2D()
panelCoverTree()
panelCrop()
panelMDSClassique()
panelMethodProj()
panelModeAfficheSVM()
panelNoyau()
panelOutilLoupe()
panelParamEspace()
panelParamStyle()
panelPreTraitement()
panelRemiseZero()
panelSVM()
panelStable()
allInvisible()



#connexion des items des menus
gSignalConnect(ND3D_item,"activate",vueND3D)
gSignalConnect(Distance3D_item,"activate",vueDistance3D)
gSignalConnect(Aspect_item,"activate",vueAspect)
gSignalConnect(Classification_item,"activate",vueClassification)
gSignalConnect(SVM_item,"activate",vueSVM)
gSignalConnect(Crop_item,"activate",vueCrop)
gSignalConnect(fichierlocal_item,"activate",chargerFichierLocal)
gSignalConnect(Quitter_item,"activate",quitterExplorer3D)
gSignalConnect(Demo_item,"activate",fn_btn_0)
gtkWindowResize(fenetreGauche,350,768)
